/*
* TacticaByterider2.java
*
* Created on 18 de marzo de 2007, 18:32
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/

package futbol.tacticas.concursantes2007.ByteriderFC ;

import futbol.General;
import futbol.tacticas.concursantes.Tactica;

import java.awt.*;
import java.util.Vector;
import futbol.tacticas.*;

/**
*
* @author Fernando Blanco Oroz
*/
public class TacticaByterider implements Tactica
{
// Clase Jugador
abstract class Jugador
{
    protected Point posicion = new Point();
    protected Point posicionInicial = new Point();
    protected int numero;
    protected int tipo;
    protected int potencia;

    public Jugador(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }

    public Jugador(Point posicionJugador, int numero)
    {
        posicion.setLocation(posicionJugador);
        tipo = PORTERO;
    }

    public Jugador()
    {
        numero = 0;
        tipo = PORTERO;
    }

    public int getNumero()
    {
        return this.numero;
    }

    public boolean esDefensa()
    {
        return (tipo == DEFENSA);
    }

    public boolean esCentrocampista()
    {
        return (tipo == CENTROCAMPISTA);
    }

    public boolean esDelantero()
    {
        return (tipo == DELANTERO);
    }

    public Point getPosicion ()
    {
        return posicion;
    }

    public void setPosicion (Point nuevaPosicion)
    {
        this.posicion.setLocation(nuevaPosicion);
    }

    public void Muevete(double x,double y)
    {
        ordenes.add(new ComandoIrA(this.numero,x,y));
    }

    public void Muevete(SituacionJugadores sj)
    {
        ordenes.add(new ComandoIrA(this.numero,0,0));
    }         

    private int DetectarDelantero(SituacionJugadores sj)
    {   
        return sj.getContrarioMasCerca(posicionInicial.getX(),posicionInicial.getY());
    }        

    protected void DecidirAQuienPasar(int[] listaPosiblesJugadores)
    {
        double maximo=0;
        int neo=listaPosiblesJugadores[0];
        boolean decidido = false;

        // Si es el saque de centro
        if ((balon.getX()==0)&&(balon.getY()==0))
        {            
            ordenes.add(new ComandoPase(this.numero,EXTREMO_DERECHO));
            recienGolpeada = true;
        }
        else
        {
            // Recta de la pelota al jugador destino
            // y = mx + n
            double mRectaBolaJugadorDestino=1;
            double nRectaBolaJugadorDestino=1;

            double nRectaJugadorContrarioATrayectoriaBola=1;

            double xInterseccion=0;
            double yInterseccion=0;

            double distanciaContrarioATrayectoria=100;

            boolean []estaEnMedio=new boolean[11];

            double nRectaComprobacion1=0;
            double nRectaComprobacion2=0;                

            for(int i=0;i<listaPosiblesJugadores.length;i++)
            {
                // Calculamos si hay linea de pase
                // Calculo de la recta de la pelota al jugador destino
                mRectaBolaJugadorDestino = (balon.getY()-byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getY())/(balon.getX()-byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getX());
                nRectaBolaJugadorDestino = balon.getY() - mRectaBolaJugadorDestino * balon.getX();                    

                // Calculo de la distancia de cada jugador contrario a la recta interseccion de la trayectoria de la pelota
                for (int j=0;j<11;j++)
                {
                   // Se calcula la recta ortogonal del jugador contrario a la recta que trazaria el pase.
                   // La pendiente es la misma q la anterior recta multiplicada por -1
                   nRectaJugadorContrarioATrayectoriaBola = equipoContrario.getJugador(j).getPosicion().getY() + mRectaBolaJugadorDestino * equipoContrario.getJugador(j).getPosicion().getX();

                   // Se calcula el punto de interseccion entre las dos rectas
                   xInterseccion = nRectaJugadorContrarioATrayectoriaBola - nRectaBolaJugadorDestino / 2 * mRectaBolaJugadorDestino;
                   yInterseccion = mRectaBolaJugadorDestino * xInterseccion + nRectaBolaJugadorDestino;

                   // Se calcula la distancia del punto interseccion al jugador contrario
                   distanciaContrarioATrayectoria = General.getDistancia(xInterseccion,yInterseccion,byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getX(),byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getY());

                   if (distanciaContrarioATrayectoria>=10)
                   {
                       estaEnMedio[j] = false;
                   }
                   else
                   {
                       nRectaComprobacion1 = balon.getY() + mRectaBolaJugadorDestino * balon.getX();                           
                       nRectaComprobacion2 = byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getY() + mRectaBolaJugadorDestino * byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getX();

                       if (equipoContrario.getJugador(j).getPosicion().getY()> (-mRectaBolaJugadorDestino) * equipoContrario.getJugador(j).getPosicion().getX() + nRectaComprobacion1
                          ||
                           equipoContrario.getJugador(j).getPosicion().getY()< (-mRectaBolaJugadorDestino) * equipoContrario.getJugador(j).getPosicion().getX() + nRectaComprobacion2)                           
                       {
                            estaEnMedio[j] = false;
                       }
                       else 
                       {
                            estaEnMedio[j] = true;
                       }
                   }
                }                    

                // Entre los que tienen linea de pase vemos el mas desmarcado
                if ((distaciaAJugadorMascercano[listaPosiblesJugadores[i]]>maximo) // Si es mayor al maximo actual
                    &&(numero!=listaPosiblesJugadores[i])      // y no es quien esta pasando
                    &&(distaciaDeMisJugadoresABalon[i]<=this.potencia*20)  // y no estamos pasando demasiado lejos
                    &&(distaciaDeMisJugadoresABalon[i]>10)  // y no estamos pasando demasiado cerca
                    &&!estaEnMedio[i]) // Y no hay contrarios en la trayectoria
                {
                    maximo = distaciaAJugadorMascercano[listaPosiblesJugadores[i]];
                    neo = listaPosiblesJugadores[i];
                    decidido = true;
                }
            }        
            if (decidido)
            {
                if (!recienGolpeada)
                {      
                    ordenes.add(new ComandoPase(this.numero,listaPosiblesJugadores[0]));
                    recienGolpeada = true;
                }                                    
            }
            else
            {
                if (!recienGolpeada)
                {   
                    double max = 0;
                    double aux = 0;
                    for(int i=0;i<listaPosiblesJugadores.length;i++)
                    {
                        aux = General.getDistancia(centroEquipoContrarioX,centroEquipoContrarioY,byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getX(),byteriderFC.getJugador(listaPosiblesJugadores[i]).getPosicion().getY());
                        if (aux>max)
                        {
                            max = aux;
                            neo = listaPosiblesJugadores[i];
                        }                        
                    }                    
                    ordenes.add(new ComandoPase(this.numero,neo));
                    recienGolpeada = true;                    
                }
            }
        }
    }        
    
    public int getVelocidad()
    {
        return (10 - this.potencia);
    }

    protected void RealizarAutopase(SituacionJugadores sj)
    {
        int velocidad = this.getVelocidad();
        double distancia = velocidad * CONSTANTE_AUTOPASE;
        
        double incremento45 = distancia / Math.sqrt(2);
        double incremento30y = distancia / 2;
        double incremento30x = incremento30y * Math.sqrt(3);
        
        int contrarioFrente = sj.getContrarioMasCerca(balon.getX()+distancia,balon.getY());
        int contrarioArriba45 = sj.getContrarioMasCerca(balon.getX()+incremento45,balon.getY()-incremento45);
        int contrarioAbajo45 = sj.getContrarioMasCerca(balon.getX()+incremento45,balon.getY()+incremento45);
        int contrarioArriba30 = sj.getContrarioMasCerca(balon.getX()+incremento30x,balon.getY()-incremento30y);
        int contrarioAbajo30 = sj.getContrarioMasCerca(balon.getX()+incremento30x,balon.getY()+incremento30y);
        int contrarioArriba = sj.getContrarioMasCerca(balon.getX(),balon.getY()-distancia);
        int contrarioAbajo = sj.getContrarioMasCerca(balon.getX(),balon.getY()+distancia);

        double distanciaFrente = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioFrente).getPosicion().getX(),equipoContrario.getJugador(contrarioFrente).getPosicion().getY());
        double distanciaArriba45 = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioArriba45).getPosicion().getX(),equipoContrario.getJugador(contrarioArriba45).getPosicion().getY());
        double distanciaAbajo45 = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioAbajo45).getPosicion().getX(),equipoContrario.getJugador(contrarioAbajo45).getPosicion().getY());
        double distanciaArriba30 = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioArriba30).getPosicion().getX(),equipoContrario.getJugador(contrarioArriba30).getPosicion().getY());
        double distanciaAbajo30 = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioAbajo30).getPosicion().getX(),equipoContrario.getJugador(contrarioAbajo30).getPosicion().getY());
        double distanciaArriba = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioArriba).getPosicion().getX(),equipoContrario.getJugador(contrarioArriba).getPosicion().getY());
        double distanciaAbajo = General.getDistancia(balon.getX(),balon.getY(),equipoContrario.getJugador(contrarioAbajo).getPosicion().getX(),equipoContrario.getJugador(contrarioAbajo).getPosicion().getY());

        double [] distanciasOrdenadas = new double[7];

        distanciasOrdenadas[0]=distanciaFrente;
        distanciasOrdenadas[1]=distanciaArriba45;
        distanciasOrdenadas[2]=distanciaAbajo45;
        distanciasOrdenadas[3]=distanciaArriba30;
        distanciasOrdenadas[4]=distanciaAbajo30;
        distanciasOrdenadas[5]=distanciaArriba;
        distanciasOrdenadas[6]=distanciaAbajo;

        double dmax=0;
        int max=0;
        for (int i=0;i<5;i++)
        {
            if (distanciasOrdenadas[i]>dmax)
            {
                max=i;
                dmax=distanciasOrdenadas[i];
            }
        }

        switch (max)
        {
            case 0: // Al frente
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX()+distancia,balon.getY()));
                ordenes.add(new ComandoIrA(numero,balon.getX()+distancia-12,balon.getY()));                
            break;
            case 1: // Arriba 45 grados
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX()+incremento45,balon.getY()-incremento45));
                ordenes.add(new ComandoIrA(numero,balon.getX()+incremento45-8,balon.getY()-incremento45+8));
            break; 
            case 2: //Abajo 45 grados
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX()+incremento45,balon.getY()+incremento45));                                    
                ordenes.add(new ComandoIrA(numero,balon.getX()+incremento45-8,balon.getY()-incremento45-8));
            break;
            case 3: // Arriba 30 grados
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX()+incremento30x,balon.getY()-incremento30y));
                ordenes.add(new ComandoIrA(numero,balon.getX()+incremento30x-9,balon.getY()-incremento30y+6));
            break;
            case 4: // Abajo 30 grados
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX()+incremento30x,balon.getY()+incremento30y));                    
                ordenes.add(new ComandoIrA(numero,balon.getX()+incremento30x-9,balon.getY()-incremento30y-6));
            break;                
            case 5: // Arriba
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX(),balon.getY()-distancia));
                ordenes.add(new ComandoIrA(numero,balon.getX(),balon.getY()-distancia+12));
            break;                
            case 6: // Abajo
                ordenes.add (new ComandoGolpearBola(this.numero,balon.getX(),balon.getY()+distancia));
                ordenes.add(new ComandoIrA(numero,balon.getX(),balon.getY()-distancia-12));
            break;                                
        }        
        recienGolpeada = true;
    }        
    

    public Point getPosicionInicial ()
    {
        return posicionInicial;
    }

    protected boolean posibleGol(int jugador)
    {
        boolean posibleGol=false;
        double distanciaPosteArriba,distanciaPosteAbajo;

        distanciaPosteArriba=General.getDistancia(this.getPosicion().getX(),this.getPosicion().getY(),160,-30);
        distanciaPosteAbajo=General.getDistancia(this.getPosicion().getX(),this.getPosicion().getY(),160,30);

        // Si estamos lo suficientemente cerca de la porteria
        if (Math.min(distanciaPosteArriba,distanciaPosteAbajo)<=potencia*14)
        {
            // Puntos (160,+-30) y (145,+-120)
            // y>=60x-9630
            // y<=-60x+9570
            //if ((this.getPosicion().getY()>=(this.getPosicion().getX()*60-9630))&&(this.getPosicion().getY()<=(this.getPosicion().getX()*(-60)+9570)))
            //{
                posibleGol = true;                        
            //}
        }            
        return posibleGol;
    }
}

private class Equipo
{
    private Jugador[] jugadores  = new Jugador[11];
    private int numeroDefensas = 4;
    private int numeroCentrocampistas = 4;
    private int numeroDelanteros =2;
    private int defensaMasDesmarcado;
    private int centrocampistaMasDesmarcado;
    private int delanteroMasDesmarcado;

    private double centroEquipoX;
    private double centroEquipoY;
    

    public Equipo(int numDefensas,int numCentrocampistas,int numDelanteros)
    {
        jugadores = new Jugador[11];

        jugadores[0] = new Portero(new Point(jugadoresInicio[0][0],jugadoresInicio[0][1]),0,PORTERO);
        if (numDefensas+numCentrocampistas+numDelanteros==10)
        {
            int i=1;
            for (;i<=numDefensas;i++)
            {
                jugadores[i] = new Defensa(new Point(jugadoresInicio[i][0],jugadoresInicio[i][1]),i,DEFENSA,jugadoresInicio[i][2]);
            }                    
            jugadores[4] = new Extremo(new Point(jugadoresInicio[4][0],jugadoresInicio[4][1]),4,CENTROCAMPISTA,jugadoresInicio[4][2]);
            jugadores[5] = new Centrocampista(new Point(jugadoresInicio[5][0],jugadoresInicio[5][1]),5,CENTROCAMPISTA,jugadoresInicio[5][2]);
            jugadores[6] = new Extremo(new Point(jugadoresInicio[6][0],jugadoresInicio[6][1]),6,CENTROCAMPISTA,jugadoresInicio[6][2]);
            jugadores[7] = new Centrocampista(new Point(jugadoresInicio[7][0],jugadoresInicio[7][1]),7,CENTROCAMPISTA,jugadoresInicio[7][2]);
            jugadores[8] = new Delantero(new Point(jugadoresInicio[8][0],jugadoresInicio[8][1]),8,DELANTERO,jugadoresInicio[8][2]);
            jugadores[9] = new DelanteroCentro(new Point(jugadoresInicio[9][0],jugadoresInicio[9][1]),9,DELANTERO,jugadoresInicio[9][2]);
            jugadores[10] = new Delantero(new Point(jugadoresInicio[10][0],jugadoresInicio[10][1]),10,DELANTERO,jugadoresInicio[10][2]);

        }
    }      

    public void setAlineacion(int numDefensas, int numCentrocampistas, int numDelanteros)
    {            
        numeroDefensas = numDefensas;
        numeroCentrocampistas = numCentrocampistas;
        numeroDelanteros = numDelanteros;
    }

    public void CalculaDesmarques()
    {
        defensaMasDesmarcado = 0;
        double distanciaDefensaMasDesmarcado=0;
        centrocampistaMasDesmarcado = 0;
        double distanciaCentrocampistaMasDesmarcado=0;
        delanteroMasDesmarcado = 0;
        double distanciaDelanteroMasDesmarcado=0;

        for (int i=1;i<11;i++)
        {
            if (jugadores[i].esDefensa())
            {
                if (distanciaDefensaMasDesmarcado<distaciaAJugadorMascercano[i])
                {
                    defensaMasDesmarcado = i;
                    distanciaDefensaMasDesmarcado = distaciaAJugadorMascercano[i];                        
                }                
            }                
            if (jugadores[i].esCentrocampista())
            {
                if (distanciaCentrocampistaMasDesmarcado<distaciaAJugadorMascercano[i])
                {
                    centrocampistaMasDesmarcado = i;
                    distanciaCentrocampistaMasDesmarcado = distaciaAJugadorMascercano[i];
                }                                    
            }
            if (jugadores[i].esDelantero())
            {
                if (distanciaDelanteroMasDesmarcado<distaciaAJugadorMascercano[i])
                {
                    delanteroMasDesmarcado = i;
                    distanciaDelanteroMasDesmarcado = distaciaAJugadorMascercano[i];                        
                }                                                        
            }
        }
    }

    public int getDefensaMasDesmarcado()
    {
        return defensaMasDesmarcado;
    }

    public int getCentrocampistaMasDesmarcado()
    {
        return centrocampistaMasDesmarcado;
    }

    public int getDelanteroMasDesmarcado()
    {
        return delanteroMasDesmarcado;
    }        

    public Jugador getJugador(int numero)
    {
        return jugadores[numero];
    }

    public void setPosicion (Point jugadoresNuevos[])
    {            
        for (int i=0;i<11;i++)
        {
            jugadores[i].setPosicion(jugadoresNuevos[i].getLocation());
        }
    }
}    

private class Portero extends Jugador
{
    public Portero()
    {
        super();
        posicion = new Point();
        numero = 0;
        tipo = PORTERO;
    }        

    public Portero(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo)
    {
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
    }        

    public void Muevete(SituacionJugadores sj)
    {
        double y = 0;
        double x = 0;

        double yaux=0;

        yaux = n-160*m;

        if ((jugadorMasCercano==PORTERO) // Si el portero es el mas cercano y la pelota va despacio
                &&(sj.estoyMasCercaDeBola())
                &&(distanciaRecorridaPorBalon<=15))
        {
            // Moverse a la pelota
            x = balon.getX();   
            y = balon.getY();
        }
        else if ((yaux<=30)&&(yaux>=-30)) // Si va a porteria la pelota
        {
            // El portero se pone en medio de la direccion de la pelota
            y = n - 155*m;
            x = -155;
        }          
        else
        {
            // El portero se pone entre de la pelota y el punto medio de la porteria + un pequeo incremento para cubrir el palo corto
            x = -155;                
            if (balon.getY()>=20)
            {
                y = (-155) * a + b + 10;                    
            }
            else if (balon.getY()<=-20)
            {
                y = (-155) * a + b - 10;    
            }
            else
            {
                y = (-155) * a + b;    
            }
        }                

        if (distaciaDeMisJugadoresABalon[PORTERO]<DISTANCIA_GOLPEO_BALON)
        {
            if (!recienGolpeada)
            {
                int [] listaJugadores = new int [2];

                listaJugadores[0] = EXTREMO_DERECHO;
                listaJugadores[1] = EXTREMO_IZQUIERDO;

                DecidirAQuienPasar(listaJugadores);
            }
        }
        else
        {
            // El portero se mueve en la direccion decidida anteriormente
            ordenes.add(new ComandoIrA(PORTERO,x,y));
        }                    
    }
}

private class Defensa extends Jugador
{
    public Defensa(int numero)
    {
        super();
        posicion = new Point();
        numero = numero;
        tipo = DEFENSA;
    }        

    public Defensa(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        super();
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }                

    public void Muevete(SituacionJugadores sj)
    {
        //if ((jugadorMasCercano==this.numero)&&(distaciaDeMisJugadoresABalon[this.numero]<DISTANCIA_GOLPEO_BALON))
        if (distaciaDeMisJugadoresABalon[this.numero]<DISTANCIA_GOLPEO_BALON)
        {
            if (!recienGolpeada)
            {
                int []listaJugadoresAPasar=new int[4];

                listaJugadoresAPasar[0]=EXTREMO_IZQUIERDO;
                listaJugadoresAPasar[1]=CENTROCAMPISTA_OFENSIVO;
                listaJugadoresAPasar[2]=EXTREMO_DERECHO;
                listaJugadoresAPasar[3]=CENTROCAMPISTA_DEFENSIVO;

                DecidirAQuienPasar(listaJugadoresAPasar);                
                recienGolpeada = true;
            }
        }
        else if (jugadorMasCercano!=numero)
        {
            int aquiendefender = super.DetectarDelantero(sj);
            if ((distanciaRecorridaPorBalon>=distaciaDeMisJugadoresABalon[numero]-distaciaDeMisJugadoresABalonTurnoAnterior[numero]+5)&&
                (General.getDistancia(balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY(),posicion.getX(),posicion.getY())<30))
            {
                ordenes.add(new ComandoIrA(this.numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
            }
            // Si no soy el mascercano y no viene a mi la pelota
            else if (!jugadorContrarioDefendido[aquiendefender])
            {
                // Defiendo al hombre
                double x,y,m,n; 
                
                try
                {
                    m = (balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())/(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX());
                    n =  balon.getY() - m * balon.getX();
                    
                    if (m==0)
                    {
                        y = equipoContrario.getJugador(aquiendefender).getPosicion().getY();
                        if (balon.getX()>equipoContrario.getJugador(aquiendefender).getPosicion().getX())
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getY() + DISTANCIA_DEFENSA;
                        }
                        else
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getY() - DISTANCIA_DEFENSA;
                        }
                    }
                    else
                    {
                        if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() + DISTANCIA_DEFENSA;                            
                            x = (y - n) / m;
                        }
                        else if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            < -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getX() - DISTANCIA_DEFENSA;
                            y = m * x + n;      
                        }
                        else if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            < (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getX() + DISTANCIA_DEFENSA;
                            y = m * x + n;     
                        }
                        else
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() - DISTANCIA_DEFENSA;
                            x = (y - n) / m;          
                        }
                    }                      
                }
                catch(Exception ex)
                {
                    //System.out.println("Excepcion");
                    x = a;
                    y = b;
                }
                
                if (Double.isNaN(x)||Double.isNaN(y))
                {
                    x = a;
                    y = b;
                }
                ordenes.add(new ComandoIrA(this.numero,x,y));                                           

                jugadorContrarioDefendido[aquiendefender]=true;
            }
            else
            {                
                ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX,this.getPosicionInicial().getY()+IncrementoEquipoY));                
            }
        }        
        else // Si es el jugador mas cercano a la pelota
        {
            // Sigue la pelota
            ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
        }            
    }        
}

private class Centrocampista extends Jugador
{
    public Centrocampista(int numero)
    {
        super();
        posicion = new Point();
        numero = numero;
        tipo = CENTROCAMPISTA;
    }                

    public Centrocampista(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        super();
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }        

    public void Muevete(SituacionJugadores sj)
    {
        //if ((jugadorMasCercano==numero)&&(distaciaDeMisJugadoresABalon[numero]<10))
        if (distaciaDeMisJugadoresABalon[numero]<DISTANCIA_GOLPEO_BALON)
        {
            if (posibleGol(numero)) // Dispara
            {
                if (!recienGolpeada)
                {
                    ordenes.add(new ComandoTiroAPuerta(numero,0));
                    recienGolpeada = true;
                }
            }   
            else
            {
                if ((balon.getX()>=byteriderFC.getJugador(DELANTERO_IZQUIERDO).getPosicion().getX()-10)
                &&(balon.getX()>=byteriderFC.getJugador(DELANTERO_DERECHO).getPosicion().getX()-10))
                {
                    if (!recienGolpeada)
                    {
                        int []listaJugadoresAPasar=new int[5];

                        listaJugadoresAPasar[0]=DELANTERO_CENTRO;
                        listaJugadoresAPasar[1]=DELANTERO_IZQUIERDO;
                        listaJugadoresAPasar[2]=DELANTERO_DERECHO;
                        listaJugadoresAPasar[3]=EXTREMO_DERECHO;
                        listaJugadoresAPasar[4]=EXTREMO_IZQUIERDO;

                        DecidirAQuienPasar(listaJugadoresAPasar);    
                        recienGolpeada = true;
                    }
                }
                else
                {
                    if (!recienGolpeada)
                    {
                        int []listaJugadoresAPasar=new int[3];

                        listaJugadoresAPasar[0]=DELANTERO_IZQUIERDO;
                        listaJugadoresAPasar[1]=DELANTERO_DERECHO;
                        listaJugadoresAPasar[2]=DELANTERO_CENTRO;

                        DecidirAQuienPasar(listaJugadoresAPasar);                        
                        recienGolpeada = true;
                    }
                }
            }
        }
        else if (jugadorMasCercano!=numero)
        {
            int aquiendefender = super.DetectarDelantero(sj);

            if ((distanciaRecorridaPorBalon>=distaciaDeMisJugadoresABalon[numero]-distaciaDeMisJugadoresABalonTurnoAnterior[numero]+5)&&
                (General.getDistancia(balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY(),posicion.getX(),posicion.getY())<30))
            {
                ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
            }
            else if (!jugadorContrarioDefendido[aquiendefender])
            {
                // Defiendo al hombre
                double x,y,m,n; 
                
                try
                {
                    m = (balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())/(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX());
                    n =  balon.getY() - m * balon.getX();
                    
                    if (m==0)
                    {
                        x = equipoContrario.getJugador(aquiendefender).getPosicion().getX();
                        if (balon.getY()>equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() + DISTANCIA_DEFENSA;
                        }
                        else
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() - DISTANCIA_DEFENSA;
                        }
                    }
                    else
                    {
                        if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() + DISTANCIA_DEFENSA;                            
                            x = (y - n) / m;
                        }
                        else if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            < -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getX() - DISTANCIA_DEFENSA;
                            y = m * x + n;                        
                        }
                        else if (((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            < (balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX()))
                            &&
                            ((balon.getY()-equipoContrario.getJugador(aquiendefender).getPosicion().getY())
                            >= -(balon.getX()-equipoContrario.getJugador(aquiendefender).getPosicion().getX())))
                        {
                            x = equipoContrario.getJugador(aquiendefender).getPosicion().getX() + DISTANCIA_DEFENSA;
                            y = m * x + n;                        
                        }
                        else
                        {
                            y = equipoContrario.getJugador(aquiendefender).getPosicion().getY() - DISTANCIA_DEFENSA;
                            x = (y - n) / m;                            
                        }
                    }                      
                }
                catch(Exception ex)
                {
                    x = a;
                    y = b;
                }
                
                if (Double.isNaN(x)||Double.isNaN(y))
                {
                    x = a;
                    y = b;
                }
                ordenes.add(new ComandoIrA(this.numero,x,y));                                           

                jugadorContrarioDefendido[aquiendefender]=true;
            }
            else
            {
                ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX,this.getPosicionInicial().getY()+IncrementoEquipoY/2));
            }
        }                        
        else
        {
            // Sigue la pelota
            //ordenes.add(new ComandoIrA(numero,balon.getX(),balon.getY()));
            ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
        }            
    }
}

private class Extremo extends Jugador
{
    public Extremo(int numero)
    {
        super();
        posicion = new Point();
        numero = numero;
        tipo = CENTROCAMPISTA;
    }                

    public Extremo(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        super();
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }            

    public void Muevete(SituacionJugadores sj)
    {
        if (distaciaDeMisJugadoresABalon[numero]<DISTANCIA_GOLPEO_BALON)
        {
            if (posibleGol(numero)) // Dispara
            {
                ordenes.add(new ComandoTiroAPuerta(numero,0));
                recienGolpeada = true;                
            }   /*
            else if ((distaciaAJugadorMascercano[this.numero]>20)                        
                    //&&(equipoContrario.getJugador(sj.getContrarioMasCerca(this.numero)).posicion.getX()<=this.getPosicion().getX())
                    &&(balon.getX()<=155))
            {              
                if (!recienGolpeada)
                {
                    this.RealizarAutopase(sj);                    
                    recienGolpeada = true;
                }
            }*/
            else
            {             
                if (this.numero==EXTREMO_IZQUIERDO)
                {
                    if (!recienGolpeada)                    
                    {
                        int []listaJugadoresAPasar=new int[2];

                        listaJugadoresAPasar[0]=DELANTERO_IZQUIERDO;
                        listaJugadoresAPasar[1]=DELANTERO_CENTRO;

                        super.DecidirAQuienPasar(listaJugadoresAPasar);                    
                        recienGolpeada = true;
                    }
                }
                else
                {
                    if (!recienGolpeada)
                    {
                        int []listaJugadoresAPasar=new int[2];

                        listaJugadoresAPasar[0]=DELANTERO_DERECHO;
                        listaJugadoresAPasar[1]=DELANTERO_CENTRO;
                        
                        super.DecidirAQuienPasar(listaJugadoresAPasar);        
                        recienGolpeada = true;
                    }
                }
            }
        }
        else if (jugadorMasCercano!=numero)
        {               
            // Si el balon va hacia mi
            if ((distanciaRecorridaPorBalon>=distaciaDeMisJugadoresABalon[numero]-distaciaDeMisJugadoresABalonTurnoAnterior[numero]+5)&&
                (General.getDistancia(balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY(),posicion.getX(),posicion.getY())<20))
            {
                ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
            }
            else
            {                    
                if (balon.getX()>0)
                {
                    ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX*2,this.getPosicionInicial().getY()+IncrementoEquipoY/2));                                        
                }
                else
                {
                    ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX,this.getPosicionInicial().getY()+IncrementoEquipoY/2));                    
                }
            }                

        }                        
        else
        {
            // Sigue la pelota
            ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
        }            
    }
}

private class Delantero extends Jugador
{
    public Delantero(int numero)
    {
        super();
        posicion = new Point();
        numero = numero;
        tipo = DELANTERO;
    }       

    public Delantero(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        super();
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }                         

    public void Muevete(SituacionJugadores sj)
    {
        //if ((jugadorMasCercano==numero)&&(distaciaDeMisJugadoresABalon[this.numero]<DISTANCIA_GOLPEO_BALON))
        if (distaciaDeMisJugadoresABalon[numero]<DISTANCIA_GOLPEO_BALON)
        {
            if (posibleGol(numero)) // Dispara
            {
                if (!recienGolpeada)
                {
                    ordenes.add(new ComandoTiroAPuerta(numero,0));
                    recienGolpeada = true;
                }
            }
            /*
            else if ((distaciaAJugadorMascercano[this.numero]>25)  
                    &&(equipoContrario.getJugador(sj.getContrarioMasCerca(this.numero)).posicion.getX()<=this.getPosicion().getX())
                    &&(balon.getX()<=155))
            {          
                if (!recienGolpeada)
                {                              
                    this.RealizarAutopase(sj);
                    recienGolpeada = true;
                }
            }*/
            else // Pasa
            {
                if (!recienGolpeada)
                {
                    ordenes.add(new ComandoPase(this.numero,DELANTERO_CENTRO));
                    recienGolpeada = true;                                            
                }
            }
        }
        else if (jugadorMasCercano!=numero)
        {                
            // Si el balon va hacia mi
            if ((distanciaRecorridaPorBalon>=distaciaDeMisJugadoresABalon[numero]-distaciaDeMisJugadoresABalonTurnoAnterior[numero]+5)&&
                (General.getDistancia(balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY(),posicion.getX(),posicion.getY())<20))
            {
                ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
            }
            else
            {              
                if (balon.getX()>-20)
                {
                    ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX*2,this.getPosicionInicial().getY()+IncrementoEquipoY*2));                                        
                }
                else
                {
                    ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX/2,this.getPosicionInicial().getY()));                    
                }
            }
        }                                                        
        else
        {        
            // Sigue la pelota
            //ordenes.add(new ComandoIrA(numero,balon.getX(),balon.getY()));
            ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
        }             
    }
}

private class DelanteroCentro extends Jugador
{
    public DelanteroCentro(int numero)
    {
        super();
        posicion = new Point();
        numero = numero;
        tipo = DELANTERO;
    }       

    public DelanteroCentro(Point posicionInicialJugador, int numeroNuevo,int tipoNuevo, int potenciaNueva)
    {
        super();
        posicionInicial.setLocation(posicionInicialJugador);
        posicion.setLocation(posicionInicialJugador);
        numero = numeroNuevo;
        tipo = tipoNuevo;
        potencia = potenciaNueva;
    }                         

    public void Muevete(SituacionJugadores sj)
    {
        //if ((jugadorMasCercano==numero)&&(distaciaDeMisJugadoresABalon[this.numero]<DISTANCIA_GOLPEO_BALON))
        if (distaciaDeMisJugadoresABalon[numero]<DISTANCIA_GOLPEO_BALON)
        {
            if (!recienGolpeada)
            {
                ordenes.add(new ComandoTiroAPuerta(numero,0));
                recienGolpeada = true;
            }
        }
        else if (jugadorMasCercano!=numero)
        {                
            // Si el balon va hacia mi
            if ((distanciaRecorridaPorBalon>=distaciaDeMisJugadoresABalon[numero]-distaciaDeMisJugadoresABalonTurnoAnterior[numero]+5)&&
                (General.getDistancia(balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY(),posicion.getX(),posicion.getY())<20))
            {
                ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
            }
            else
            {
                ordenes.add(new ComandoIrA(numero,this.getPosicionInicial().getX()+IncrementoEquipoX/2,this.getPosicionInicial().getY()+IncrementoEquipoY));                                    
            }
        }                                                        
        else
        {        
            // Sigue la pelota
            //ordenes.add(new ComandoIrA(numero,balon.getX(),balon.getY()));
            ordenes.add(new ComandoIrA(numero,balonTurnoSiguiente.getX(),balonTurnoSiguiente.getY()));
        }             
    }
}

private int jugadoresInicio[][]={
    {-150,0,6},  // Portero 1 
    {-110,-70,6},  // Defensa lateral izquierdo 2
    {-120,0,6},  // Defensa central 3
    {-110,70,6},  // Defensa lateral derecho 4
    {-30,-85,7},  // Extremo izquierdo 5
    {-60,0,6},  // Centrocampista defensivo 6
    {-30,85,7},  // Extremo derecho 7
    {-10,0,6},  // Centrocampista ofensivo 8
    {40,-55,6},  // Delantero izquierdo 9
    {80,0,7},  // Delantero centro 10
    {40,55,6}  // Delantero derecho 11
};

// Constantes que representan el tipo de los jugadores
final int LATERAL_IZQUIERDO = 1;
final int DEFENSA_CENTRAL = 2;
final int LATERAL_DERECHO = 3;
final int EXTREMO_IZQUIERDO = 4;
final int CENTROCAMPISTA_DEFENSIVO = 5;
final int EXTREMO_DERECHO = 6;
final int CENTROCAMPISTA_OFENSIVO = 7;
final int DELANTERO_IZQUIERDO = 8;
final int DELANTERO_CENTRO = 9;
final int DELANTERO_DERECHO = 10;

final int PORTERO = 0;
final int DEFENSA = 1;
final int CENTROCAMPISTA = 2;
final int DELANTERO = 3;

final int DISTANCIA_DEFENSA = 10;
final int DISTANCIA_GOLPEO_BALON = 10;
final double CONSTANTE_AUTOPASE = 7;

private Vector<Comando> ordenes = new Vector();

private Point balon = new Point();
private Point balonTurnoAnterior = new Point();
private Point balonTurnoSiguiente = new Point();
private Equipo byteriderFC = new Equipo(3,4,3);
private Equipo equipoContrario = new Equipo(4,4,2);
private int jugadorMasCercano;

private double []distaciaDeMisJugadoresABalon = new double[11];
private double []distaciaDeMisJugadoresABalonTurnoAnterior = new double[11];
private double []distaciaAJugadorMascercano = new double[11];    

// Recta trazada por la pelota y=mx+n
private double n;
private double m;

// Recta desde el balon hasta el punto medio de la porteria y = ax+ b
private double a;
private double b;    

private double distanciaRecorridaPorBalon;
private double distanciaRecorridaBalonEjeX;
private double distanciaRecorridaBalonEjeY;    

private int contadorTurnos = 0;
private double IncrementoEquipoX;
private double IncrementoEquipoY;

private boolean recienGolpeada;
private int contadorTurnosSingolpear;

private boolean bandaIzquierda;
private boolean bandaDerecha;
private boolean bandaCentral;

private double centroEquipoContrarioX;
private double centroEquipoContrarioY;

private boolean []jugadorContrarioDefendido = new boolean[11];

private void Inicializacion(SituacionJugadores sj)
{        
    balon.setLocation(sj.getBola().getX(),sj.getBola().getY());

    byteriderFC.setPosicion(sj.getMisJugadores());
    equipoContrario.setPosicion (sj.getContrario());

    for (int i=0;i<11;i++)
    {
        jugadorContrarioDefendido[i]=false;
    }
}

private void PreCalculos (SituacionJugadores sj)
{
    // Se calcula el jugador mas cercano a la pelota
    jugadorMasCercano=sj.getMiJugadorMasCerca(balon.getX(),balon.getY());

    // Se calcula la distancia de cada jugador al balon
    CalculaDistanciaABalon();

    // Se calcula el defensa mas desmarcado
    int jMasCercano;
    for (int i=0;i<11;i++)
    {
        jMasCercano = sj.getContrarioMasCerca(i);
        if ((jMasCercano>=0)&&(jMasCercano<11))
        {

            distaciaAJugadorMascercano[i] = General.getDistancia(byteriderFC.getJugador(i).getPosicion().getX(),
                                                byteriderFC.getJugador(i).getPosicion().getY(),
                                                equipoContrario.getJugador(jMasCercano).getPosicion().getX(),
                                                equipoContrario.getJugador(jMasCercano).getPosicion().getY());                            
        }
        else
        {
            distaciaAJugadorMascercano[i] = 0;
        }                    
    }

    // Se calcula la recta de la recta trazada por el vector de la pelota y=mx+n
    m = (balon.getY() - balonTurnoAnterior.getY())/(balon.getX() - balonTurnoAnterior.getX());
    n = balon.getY() - m * balon.getX();

    distanciaRecorridaPorBalon = General.getDistancia(balon.getX(),balon.getY(),balonTurnoAnterior.getX (),balonTurnoAnterior.getY ());
    distanciaRecorridaBalonEjeX = balon.getX() - balonTurnoAnterior.getX();
    distanciaRecorridaBalonEjeY = balon.getY() - balonTurnoAnterior.getY();

    // Se calcula el posible posicion futura de la pelota
    balonTurnoSiguiente.setLocation(balon.getX()+distanciaRecorridaBalonEjeX,balon.getY()+distanciaRecorridaBalonEjeY);

    // Se calcula la recta desde el balon al punto medio de la porteria
    if (balon.getX ()==-160)
    {
        a = balon.getY()*100;
        b = 160;
    }
    else
    {
        a = balon.getY() / (balon.getX()+160);            
        b = 160 * a;                
    }        

    // Se calcula el centro del equipo
    double centroEquipoX = 0;
    double centroEquipoY = 0;
    double sumX = 0;
    double sumY = 0;
    for (int i=0;i<11;i++)
    {
        sumX += byteriderFC.getJugador(i).getPosicion().getX();
        sumY += byteriderFC.getJugador(i).getPosicion().getY();
    }
    centroEquipoX = sumX/11;
    centroEquipoY = sumY/11;

    IncrementoEquipoX = -(centroEquipoX - balon.getX())/2;
    IncrementoEquipoY = -(centroEquipoY - balon.getY())/2;        

    
    // Se calcula el centro del equipo contrario
    centroEquipoContrarioX = 0;
    centroEquipoContrarioY = 0;
    sumX = 0;
    sumY = 0;
    for (int i=0;i<11;i++)
    {
        sumX += equipoContrario.getJugador(i).getPosicion().getX();
        sumY += equipoContrario.getJugador(i).getPosicion().getY();
    }
    centroEquipoContrarioX = sumX/11;
    centroEquipoContrarioY = sumY/11;
    
    
    
    byteriderFC.CalculaDesmarques();

    boolean auxBalonLibre = true;
    for (int i=0;i<11;i++)
    {
        if (distaciaDeMisJugadoresABalon[i]<10)
        {
            auxBalonLibre = false;
        }
    }
    if (auxBalonLibre)
    {
        recienGolpeada = false;
    }

    if (recienGolpeada)
    {
        contadorTurnosSingolpear++;
    }
    else
    {
        contadorTurnosSingolpear=0;
    }

    if (contadorTurnosSingolpear>0)
    {
        recienGolpeada = false;
    }

    // Calculamos en que banda esta la pelota
    if (balon.getY()>=40)
    {
        bandaIzquierda = true;
        bandaDerecha = false;
        bandaCentral = false;   
    }
    else if(balon.getY()<=-40)
    {
        bandaIzquierda = false;
        bandaDerecha = true;
        bandaCentral = false;               
    }
    else
    {
        bandaIzquierda = false;
        bandaDerecha = false;
        bandaCentral = true;                           
    }
}   

private void PostCalculos()
{
    balonTurnoAnterior.setLocation(balon);       
    contadorTurnos++;        
    for (int i=0;i<11;i++)
    {
        distaciaDeMisJugadoresABalonTurnoAnterior[i]=distaciaDeMisJugadoresABalon[i];
    }
}    

public Color getColor1()
{
    return Color.blue;
}

public Color getColor2()
{
    return Color.CYAN;
}

public Color getColorNumero()
{
    return Color.black;
}

public String getNombre()
{
    return "Byterider FC";
}

public int getXInicial(int n)
{
    return jugadoresInicio[n][0];
}

public int getYInicial(int n)
{
    return jugadoresInicio[n][1];
}

public int getFuerza(int n)
{
    return jugadoresInicio[n][2];
}

public void CalculaDistanciaABalon()
{
    for (int i=0;i<11;i++)
    {

        distaciaDeMisJugadoresABalon[i] = General.getDistancia(byteriderFC.getJugador(i).getPosicion().getX(),
                                            byteriderFC.getJugador(i).getPosicion().getY(),
                                            balon.getX(),
                                            balon.getY());                    
    }
}                

public Vector<Comando> getComandos(SituacionJugadores sj)
{
    Inicializacion(sj);
    PreCalculos(sj);

    for (int i=0;i<11;i++)
    {
        byteriderFC.getJugador(i).Muevete(sj);
    }        

    PostCalculos();

    return ordenes;
}    
}